package com.xyrl.project.common.util;

import com.xyrl.common.util.ObjectUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

/**
 * @className ListUtil
 * @company 星纭融链科技服务有限公司
 * @author 徐恩源
 * @version 1.0
 * @date 2020-01-07 10:59:01
 * @Description list工具类
 */
public class ListUtil {
    public static void main(String[] args) {
        List<Integer> arr = new ArrayList<Integer>();

        List<Integer> a = Arrays.asList(1,2,3);
        List<Integer> b =  Arrays.asList(3,4,5);;

        //增加的元素组成的列表
        List<Integer> aList= getAddaListThanbList(a, b);
        for (Integer integer : aList) {
            System.out.println("增加的元素："+integer);
        }

        //减少的元素组成的列表
        List<Integer> bList= getReduceaListThanbList(a, b);
        for (Integer integer : bList) {
            System.out.println("减少的元素："+integer);
        }

//        //封装
//        arr.addAll(a);
//        arr.addAll(b);
//        arr.addAll(aList);
//        arr.addAll(bList);
//
//
//        //去重
//        cleanDisRepet(arr);
//
//        for (Integer integer : arr) {
//            System.out.println("全部元素："+integer);
//        }
    }

    /**
     * @Description: 计算列表aList相对于bList的增加的情况，兼容任何类型元素的列表数据结构
     * @param aList 本列表
     * @param bList 对照列表
     * @return 返回增加的元素组成的列表
     */
    public static <E> List<E> getAddaListThanbList(List<E> aList, List<E> bList){
        List<E> addList = new ArrayList<E>();
        if (ObjectUtil.isEmpty(aList)) {
           return addList;
        }
        for (int i = 0; i < aList.size(); i++){
            if(!myListContains(bList, aList.get(i))){
                addList.add(aList.get(i));
            }
        }
        return addList;
    }

    /**
     * @Description: 计算列表aList相对于bList的减少的情况，兼容任何类型元素的列表数据结构
     * @param aList 本列表
     * @param bList 对照列表
     * @return 返回减少的元素组成的列表
     */
    public static <E> List<E> getReduceaListThanbList(List<E> aList, List<E> bList){
        List<E> reduceaList = new ArrayList<E>();
        if (ObjectUtil.isEmpty(bList)) {
            return reduceaList;
        }
        for (int i = 0; i < bList.size(); i++){
            if(!myListContains(aList, bList.get(i))){
                reduceaList.add(bList.get(i));
            }
        }
        return reduceaList;
    }


    /**
     * @Description: 判断元素element是否是sourceList列表中的一个子元素
     * @param sourceList 源列表
     * @param element 待判断的包含元素
     * @return 包含返回 true，不包含返回 false
     */
    private static <E> boolean myListContains(List<E> sourceList, E element) {
        if (sourceList == null || element == null){
            return false;
        }
        if (sourceList.isEmpty()){
            return false;
        }
        for (E tip : sourceList){
            if(element.equals(tip)){
                return true;
            }
        }
        return false;
    }

    /**
     * @Description: 去除list重复数据
     * @param list
     * @return list
     */
    public static <E> List<E> cleanDisRepet(List<E> list){
        HashSet h = new HashSet(list);
        list.clear();
        list.addAll(h);
        return list;
    }
}
